import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Solution {
    public static void main(String[] args) {
        Solution test = new Solution();
        // int[] f = new int[]{0,1,2,2};
        // System.out.println(test.totalFruit(f));

        int[] nums = new int[]{2,3,4,2,4,3};
        System.out.println(test.minSubArrayLen(7, nums));
    }

    public int totalFruit(int[] f) {
        /**
         * 水果成篮
         * 解法：使用滑动窗口进行操作*/
        // 1 预处理
        int n = f.length;

        // 2 双指针
        int left = 0;
        int right = 0;
        int maxSize = 0;
        Map<Integer, Integer> map = new HashMap<>();
        while(right < n) {
            // -1 入map ==> map用于记录水果种类个数
            if(map.containsKey(f[right])) {
                map.put(f[right], map.get(f[right])+1);
            } else {
                map.put(f[right], 1);
            }

            // -2 判断
            if(map.size() <= 2) {
                // -符合条件，正常更新
                maxSize = Math.max(maxSize, right - left + 1);
            } else {
                // -不符合，收缩至符合
                while(map.size() > 2) {
                    map.put(f[left], map.get(f[left])-1);
                    if(map.get(f[left]) == 0) {
                        map.remove(f[left]);
                    }
                    left ++;
                }
            }
            // -3 步进
            right ++;
        }
        // 3 返回值
        return maxSize;
    }

    public int minSubArrayLen(int target, int[] nums) {
        /**
         * 长度最小的子数组优化
         * 目标：在所有子数组中找到子数组和大于等于target，并且长度最短的长度*
         * 解法：使用正统滑动窗口思想进行操作*/
        // 1 预处理
        int n = nums.length;

        // 2 滑动窗口
        int left = 0;
        int right = 0;
        int sum = 0;
        int minLength = 0x3f3f3f3f;
        while (right < n) {
            // -1 进窗口
            sum += nums[right];
            // -2 判断(题目较为简单，判断和出窗口合并)
            // -3 出窗口
            while (sum >= target) {
                // -4 更新值
                minLength = Math.min(minLength, right - left + 1);

                sum -= nums[left];
                left++;
            }
            right ++;
        }
        // 3 返回值
        return minLength == 0x3f3f3f3f ? 0 : minLength;
    }
}
